// pages/upgrade/upgrade.js
const gaiaModule = require('../../utils/gaiaManager.js')
const gaiaManager = gaiaModule.gaiaManager
const bluetoothManager = require('../../utils/bluetooth.js')

Page({
  data: {
    // 页面状态
    isLoading: true,
    showError: false,
    errorMessage: '',
    
    // 设备状态
    deviceConnected: false,
    serviceAvailable: false,
    
    // 设备信息（与安卓版本UpgradeSettingsViewModel保持一致）
    appVersion: '',
    appBuildId: '',
    gaiaVersions: '',
    
    // 开发者选项（与安卓版本UpgradeSettings.kt保持一致）
    showDeveloperOptions: false,
    upgradeLogs: false,
    useDefaultTransfer: true,
    flushData: false,
    waitForAcks: false,
    chunkSize: 250,
    
    // 传输设置可见性（与安卓版本UpgradeSettingsViewModel保持一致）
    showTransferOptions: false,
    
    // 升级进度相关
    upgradeProgress: 0,
    upgradeStatus: '',
    upgradeState: 'idle'
  },

  onLoad(options) {
    this.initPage()
    this.setupBackgroundSupport()
  },

  onShow() {
    this.loadUpgradeData()
  },

  onUnload() {
    console.log('升级页面卸载，清理事件监听器')
    
    // 确保隐藏所有loading状态
    this.ensureHideLoading()
    
    // 清理后台支持
    this.cleanupBackgroundSupport()
    
    // 清理升级监听器
    this.upgradeListeners.forEach(listener => {
      this.removeUpgradeListener(listener)
    })
    this.upgradeListeners = []
    
    // 如果升级正在进行，中止升级
    if (this.upgradeState !== 'idle' && this.upgradeState !== 'completed') {
      this.abortUpgrade()
    }
  },

  // 初始化页面
  initPage() {
    this.setData({
      isLoading: true,
      showError: false,
      errorMessage: ''
    })
  },

  // 加载升级数据（与安卓版本UpgradeSettingsViewModel.updateDeviceInformation()保持一致）
  async loadUpgradeData() {
    try {
      this.setData({ isLoading: true })
      
      // 检查设备连接状态
      const connectedDeviceInfo = wx.getStorageSync('connectedDeviceInfo')
      const lastConnectedDevice = wx.getStorageSync('lastConnectedDevice')
      const isBluetoothConnected = bluetoothManager.isConnected
      
      if (!connectedDeviceInfo || !lastConnectedDevice || !isBluetoothConnected) {
        console.log('设备连接状态检查失败:', {
          connectedDeviceInfo: !!connectedDeviceInfo,
          lastConnectedDevice: !!lastConnectedDevice,
          isBluetoothConnected: isBluetoothConnected
        })
        this.showError('Device not connected')
        return
      }
      
      this.setData({ deviceConnected: true })
      
      // 获取设备信息（与安卓版本onVersions()和onSystemInformation()一致）
      console.log('正在获取Software Updates数据...')
      await this.getDeviceInformation()
      await this.getUpgradeSettings()
      await this.checkServiceAvailability()
      
      // 初始化开发者选项（与安卓版本initDeveloperOptions()一致）
      this.initDeveloperOptions()
      
    } catch (error) {
      console.error('加载Software Updates数据失败:', error)
      this.showError('Failed to load upgrade data: ' + error.message)
    } finally {
      this.setData({ isLoading: false })
    }
  },

  // 获取设备信息（与安卓版本onVersions()和onSystemInformation()一致）
  async getDeviceInformation() {
    try {
      console.log('获取设备信息')
      
      // 检查连接状态 - 使用更宽松的检查方式
      const connectedDeviceInfo = wx.getStorageSync('connectedDeviceInfo')
      const lastConnectedDevice = wx.getStorageSync('lastConnectedDevice')
      const isBluetoothConnected = bluetoothManager.isConnected
      
      if (!connectedDeviceInfo || !lastConnectedDevice) {
        console.log('没有已连接的设备信息')
        this.setData({
          appVersion: '不可用',
          appBuildId: '不可用',
          gaiaVersions: '不可用'
        })
        // 显示友好的错误提示
        wx.showToast({
          title: '请先连接设备',
          icon: 'none',
          duration: 2000
        })
        return
      }
      
      // 如果gaiaManager未连接，尝试建立连接
      if (!gaiaManager.isConnected) {
        console.log('GAIA管理器未连接，尝试建立连接...')
        try {
          gaiaManager.setDeviceId(lastConnectedDevice)
          const connectResult = await gaiaManager.connect()
          if (!connectResult.success) {
            console.log('GAIA连接失败:', connectResult.error)
            this.setData({
              appVersion: '不可用',
              appBuildId: '不可用',
              gaiaVersions: '不可用'
            })
            // 显示连接失败提示
            wx.showToast({
              title: '设备连接失败',
              icon: 'none',
              duration: 2000
            })
            return
          }
          console.log('GAIA连接成功')
        } catch (connectError) {
          console.log('GAIA连接异常:', connectError.message)
          this.setData({
            appVersion: '不可用',
            appBuildId: '不可用',
            gaiaVersions: '不可用'
          })
          // 显示连接异常提示
          wx.showToast({
            title: '设备连接异常',
            icon: 'none',
            duration: 2000
          })
          return
        }
      }
      
      // 设置命令响应回调，获取真实的设备固件版本信息
      let deviceVersionInfo = {
        appVersion: '不可用',
        appBuildId: '不可用',
        gaiaVersions: '不可用'
      }
      
      // 创建Promise来等待命令响应
      const versionPromise = new Promise((resolve) => {
        const timeout = setTimeout(() => {
          resolve(deviceVersionInfo)
        }, 3000) // 3秒超时
        
        // 设置临时回调处理版本信息，专门为升级页面处理响应
        const originalCallback = gaiaManager.onCommandResponse
        gaiaManager.setOnCommandResponse((commandId, payload, type, vendorId) => {
          console.log('📋 [升级页面] 收到GAIA响应:', { 
            commandId: `0x${commandId.toString(16).padStart(2, '0')}`, 
            payloadLength: payload.length, 
            type, 
            vendorId: `0x${vendorId.toString(16).padStart(4, '0')}` 
          })
          
          // 处理升级页面特定的响应
          // 处理应用版本命令响应
          if (commandId === 0x05 && vendorId === 0x001D) { // GET_APPLICATION_VERSION
            if (payload && payload.length > 0) {
              // 使用与设备信息页面相同的解析方法
              const versionString = this.parseAndroidString(payload, vendorId)
              if (versionString && versionString !== '不可用') {
                deviceVersionInfo.appVersion = versionString
                // 提取构建ID（版本字符串的最后一部分）
                const versionParts = versionString.split('.')
                deviceVersionInfo.appBuildId = versionParts[versionParts.length - 1] || versionString
                console.log(`📋 [升级页面] 设备固件版本: ${versionString}`)
              }
            }
          }
          // 处理GAIA版本命令响应
          else if (commandId === 0x00 && vendorId === 0x001D) { // GET_GAIA_VERSION
            if (payload && payload.length >= 1) {
              const gaiaVersion = payload[0]
              deviceVersionInfo.gaiaVersions = `GAIA V${gaiaVersion}`
              console.log(`📋 [升级页面] GAIA协议版本: V${gaiaVersion}`)
            }
          }
          
          // 恢复原始回调
          if (originalCallback) {
            gaiaManager.setOnCommandResponse(originalCallback)
          }
          clearTimeout(timeout)
          resolve(deviceVersionInfo)
        })
      })
      
      // 发送获取应用版本命令
      await gaiaManager.sendCommand(0x05, []) // GET_APPLICATION_VERSION
      await new Promise(resolve => setTimeout(resolve, 200)) // 等待响应
      
      // 发送获取GAIA版本命令
      await gaiaManager.sendCommand(0x00, []) // GET_GAIA_VERSION
      await new Promise(resolve => setTimeout(resolve, 200)) // 等待响应
      
      // 等待版本信息收集完成
      const finalVersionInfo = await versionPromise
      
      this.setData({ 
        appVersion: finalVersionInfo.appVersion,
        appBuildId: finalVersionInfo.appBuildId,
        gaiaVersions: finalVersionInfo.gaiaVersions
      })
      
    } catch (error) {
      console.error('获取设备信息失败:', error)
      // 使用默认值
      this.setData({
        appVersion: '不可用',
        appBuildId: '不可用',
        gaiaVersions: '不可用'
      })
    }
  },

  // 获取升级设置（与安卓版本保持一致）
  async getUpgradeSettings() {
    try {
      console.log('获取升级设置')
      
      // 从本地存储获取设置（与安卓版本持久化设置一致）
      const upgradeLogs = wx.getStorageSync('upgradeLogs') || false
      const useDefaultTransfer = wx.getStorageSync('useDefaultTransfer') !== false // 默认true
      const flushData = wx.getStorageSync('flushData') || false
      const waitForAcks = wx.getStorageSync('waitForAcks') || false
      const chunkSize = wx.getStorageSync('chunkSize') || 250
      
      this.setData({
        upgradeLogs,
        useDefaultTransfer,
        flushData,
        waitForAcks,
        chunkSize
      })
      
      // 设置传输选项可见性（与安卓版本showTransferOptions()一致）
      this.setTransferOptionsVisibility(!useDefaultTransfer)
      
    } catch (error) {
      console.error('获取升级设置失败:', error)
      // 使用默认值
      this.setData({
        upgradeLogs: false,
        useDefaultTransfer: true,
        flushData: false,
        waitForAcks: false,
        chunkSize: 250
      })
    }
  },

  // 检查服务可用性（与安卓版本checkForServiceAvailability()一致）
  async checkServiceAvailability() {
    try {
      console.log('检查服务可用性')
      
      // 调用GAIA管理器检查服务可用性
      const response = await gaiaManager.checkServiceAvailability()
      if (response.success) {
        this.setData({ serviceAvailable: response.data.serviceAvailable })
      } else {
        this.setData({ serviceAvailable: false })
      }
    } catch (error) {
      console.error('检查服务可用性失败:', error)
      this.setData({ serviceAvailable: false })
    }
  },

  // 初始化开发者选项（与安卓版本initDeveloperOptions()一致）
  initDeveloperOptions() {
    // 根据构建配置决定是否显示开发者选项
    const showDeveloperOptions = true // 可以根据实际配置调整
    this.setData({ showDeveloperOptions })
  },

  // 设置传输选项可见性（与安卓版本showTransferOptions()一致）
  setTransferOptionsVisibility(visible) {
    this.setData({ showTransferOptions: visible })
  },

  // 升级日志开关变化（与安卓版本保持一致）
  onUpgradeLogsChange(e) {
    const enabled = e.detail.value
    console.log('升级日志开关变化:', enabled)
    
    this.setData({ upgradeLogs: enabled })
    wx.setStorageSync('upgradeLogs', enabled)
  },

  // 使用默认传输选项开关变化（与安卓版本setUseDefaultTransferOptions()一致）
  onUseDefaultTransferChange(e) {
    const enabled = e.detail.value
    console.log('使用默认传输选项开关变化:', enabled)
    
    if (enabled) {
      // 设置为使用默认选项，无需确认
      this.setData({ useDefaultTransfer: enabled })
      wx.setStorageSync('useDefaultTransfer', enabled)
      this.setTransferOptionsVisibility(false)
    } else {
      // 不安全操作：需要用户确认
      wx.showModal({
        title: '确认操作',
        content: '禁用默认传输选项可能会影响升级性能，确定要继续吗？',
        confirmText: '确定',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.setData({ useDefaultTransfer: enabled })
            wx.setStorageSync('useDefaultTransfer', enabled)
            this.setTransferOptionsVisibility(true)
          }
        }
      })
    }
  },

  // 刷新数据开关变化（与安卓版本保持一致）
  onFlushDataChange(e) {
    const enabled = e.detail.value
    console.log('刷新数据开关变化:', enabled)
    
    this.setData({ flushData: enabled })
    wx.setStorageSync('flushData', enabled)
  },

  // 等待确认开关变化（与安卓版本保持一致）
  onWaitForAcksChange(e) {
    const enabled = e.detail.value
    console.log('等待确认开关变化:', enabled)
    
    this.setData({ waitForAcks: enabled })
    wx.setStorageSync('waitForAcks', enabled)
  },

  // 块大小变化（与安卓版本setChunkSize()一致）
  onChunkSizeChange(e) {
    const value = parseInt(e.detail.value) || 250
    console.log('块大小变化:', value)
    
    // 验证块大小范围（与安卓版本一致）
    if (value < 1 || value > 65530) {
      const alternativeValue = value < 1 ? 1 : 65530
      wx.showModal({
        title: '块大小超出范围',
        content: `块大小必须在1到65530之间。是否设置为${alternativeValue}？`,
        confirmText: '确定',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.setData({ chunkSize: alternativeValue })
            wx.setStorageSync('chunkSize', alternativeValue)
          }
        }
      })
      return
    }
    
    this.setData({ chunkSize: value })
    wx.setStorageSync('chunkSize', value)
  },

  // 选择文件（与安卓版本startFileSelection()一致）
  onSelectFile() {
    // 检查设备连接状态
    if (!this.data.deviceConnected) {
      wx.showToast({
        title: '请先连接设备',
        icon: 'none',
        duration: 2000
      })
      return
    }
    
    // 直接启动文件选择器（与安卓版本fileSelectionLauncher.launch("*/*")一致）
    this.startFileSelection()
  },

  // 启动文件选择器（与安卓版本startFileSelection()一致）
  startFileSelection() {    
    // 使用微信小程序的文件选择API（与安卓版本fileSelectionLauncher.launch("*/*")一致）
    wx.chooseMessageFile({
      count: 1, // 只能选择一个文件
      type: 'file', // 选择文件类型
      extension: ['bin', 'hex', 'dfu', 'upgrade'], // 支持的固件文件格式
      success: (res) => {
        console.log('文件选择成功:', res)
        const file = res.tempFiles[0]
        if (file) {
          this.onFileSelectionResult(file)
        }
      },
      fail: (error) => {
        console.error('文件选择失败:', error)
        wx.showToast({
          title: '文件选择失败',
          icon: 'none',
          duration: 2000
        })
      }
    })
  },

  // 文件选择结果处理（与安卓版本onFileSelectionResult()一致）
  onFileSelectionResult(file) {
    console.log('处理文件选择结果:', file)
    
    if (!file) {
      console.log('没有选择文件')
      return
    }
    
    // 验证文件
    if (!this.validateUpgradeFile(file.name, file.size)) {
      return
    }
    
    // 创建升级选项（与安卓版本UpgradeOptions一致）
    const upgradeOptions = {
      useDefaultTransfer: this.data.useDefaultTransfer,
      expectedChunkSize: this.data.chunkSize,
      isLogged: this.data.upgradeLogs,
      isUploadFlushed: this.data.flushData,
      isUploadAcknowledged: this.data.waitForAcks,
      useRwcp: true // 默认使用RWCP
    }
    
    // 显示文件信息确认对话框
    wx.showModal({
      title: '确认固件升级',
      content: `确定要升级固件吗？\n\n文件名: ${file.name}\n大小: ${this.formatFileSize(file.size)}\n类型: 固件文件\n\n升级过程中请保持设备连接，不要关闭应用。`,
      confirmText: '开始升级',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          console.log('用户确认升级，开始升级过程')
          // 开始升级（与安卓版本viewModel.startUpgrade()一致）
          this.startUpgrade(file.path, file.name, file.size, upgradeOptions)
        } else {
          console.log('用户取消固件升级')
        }
      }
    })
  },


  // 检查更新（与安卓版本onPreferenceTreeClick()一致）
  onCheckForUpdates() {
    console.log('检查更新')
    
    // 创建升级选项（与安卓版本UpgradeOptions一致）
    const upgradeOptions = {
      useDefaultTransfer: this.data.useDefaultTransfer,
      expectedChunkSize: this.data.chunkSize,
      isLogged: this.data.upgradeLogs,
      isUploadFlushed: this.data.flushData,
      isUploadAcknowledged: this.data.waitForAcks,
      useRwcp: true
    }
    
    // 导航到下载设置页面
    wx.navigateTo({
      url: '/pages/upgrade/downloadSettings/index?options=' + encodeURIComponent(JSON.stringify(upgradeOptions))
    })
  },

  // 验证升级文件（与安卓版本一致）
  validateUpgradeFile(fileName, fileSize) {
    // 检查文件扩展名
    const validExtensions = ['.bin', '.hex', '.dfu', '.upgrade']
    const hasValidExtension = validExtensions.some(ext => 
      fileName.toLowerCase().endsWith(ext)
    )
    
    if (!hasValidExtension) {
      wx.showModal({
        title: '文件格式错误',
        content: '请选择有效的固件升级文件（.bin, .hex, .dfu, .upgrade）',
        showCancel: false,
        confirmText: '确定'
      })
      return false
    }
    
    // 检查文件大小（最大100MB）
    const maxSize = 100 * 1024 * 1024 // 100MB
    if (fileSize > maxSize) {
      wx.showModal({
        title: '文件过大',
        content: `文件大小不能超过100MB，当前文件大小：${this.formatFileSize(fileSize)}`,
        showCancel: false,
        confirmText: '确定'
      })
      return false
    }
    
    // 检查文件大小（最小1KB）
    const minSize = 1024 // 1KB
    if (fileSize < minSize) {
      wx.showModal({
        title: '文件过小',
        content: `文件大小不能小于1KB，当前文件大小：${this.formatFileSize(fileSize)}`,
        showCancel: false,
        confirmText: '确定'
      })
      return false
    }
    
    return true
  },

  // 格式化文件大小
  formatFileSize(bytes) {
    if (bytes === 0) return '0 B'
    const k = 1024
    const sizes = ['B', 'KB', 'MB', 'GB']
    const i = Math.floor(Math.log(bytes) / Math.log(k))
    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
  },

  // 升级状态管理
  upgradeState: 'idle', // idle, initialisation, connecting, connected, transferring, completed, failed, aborted
  upgradeProgress: 0,
  upgradeListeners: [],

  // 确保隐藏所有loading状态的辅助函数
  ensureHideLoading() {
    console.log('🔧 [Loading管理] 开始隐藏所有loading状态...')
    wx.hideLoading()
    // 多次调用hideLoading确保完全隐藏
    setTimeout(() => {
      console.log('🔧 [Loading管理] 第1次隐藏loading...')
      wx.hideLoading()
    }, 50)
    setTimeout(() => {
      console.log('🔧 [Loading管理] 第2次隐藏loading...')
      wx.hideLoading()
    }, 100)
    setTimeout(() => {
      console.log('🔧 [Loading管理] 第3次隐藏loading...')
      wx.hideLoading()
    }, 200)
    setTimeout(() => {
      console.log('🔧 [Loading管理] 第4次隐藏loading...')
      wx.hideLoading()
    }, 300)
    setTimeout(() => {
      console.log('🔧 [Loading管理] 第5次隐藏loading...')
      wx.hideLoading()
    }, 500)
  },

  // 添加升级进度监听器
  addUpgradeListener(listener) {
    this.upgradeListeners.push(listener)
  },

  // 移除升级进度监听器
  removeUpgradeListener(listener) {
    const index = this.upgradeListeners.indexOf(listener)
    if (index > -1) {
      this.upgradeListeners.splice(index, 1)
    }
  },

  // 通知升级进度
  notifyUpgradeProgress(progressData) {
    this.upgradeProgress = progressData.progress
    this.upgradeState = progressData.state
    
    // 更新UI
    this.setData({
      upgradeProgress: progressData.progress,
      upgradeStatus: progressData.message,
      upgradeState: progressData.state
    })
    
    // 通知监听器
    this.upgradeListeners.forEach(listener => {
      try {
        listener(progressData)
      } catch (error) {
        console.error('[升级监听器] 错误:', error)
      }
    })
  },

  // 开始升级（与安卓版本startUpgrade()一致）
  async startUpgrade(fileId, fileName, fileSize, upgradeOptions) {
    try {
      console.log('开始升级:', { fileId, fileName, fileSize, upgradeOptions })
      
      // 设置后台运行支持
      gaiaManager.setupBackgroundSupport()
      
      // 显示升级开始提示
      wx.showLoading({
        title: '正在启动升级...',
        mask: true
      })
      
      // 检查GAIA连接状态
      if (!gaiaManager.isConnected) {
        wx.hideLoading()
        wx.showToast({
          title: '设备未连接',
          icon: 'error'
        })
        return
      }
      
      // 创建文件数据对象（与安卓版本UpdateOptions一致）
      const fileData = {
        id: fileId,
        name: fileName,
        path: fileId, // 使用文件路径作为临时文件路径
        size: fileSize,
        version: 'Remote file',
        md5Checksum: null // 微信小程序无法计算MD5，设为null
      }
      
      // 添加升级进度监听器
      const upgradeListener = (progressData) => {
        this.notifyUpgradeProgress(progressData)
        // 根据状态更新UI
        switch (progressData.state) {
          case 'initialisation':
            wx.showLoading({
              title: progressData.message,
              mask: true
            })
            break
          case 'connecting':
            wx.showLoading({
              title: progressData.message,
              mask: true
            })
            break
          case 'connected':
            wx.hideLoading()
            wx.showToast({
              title: progressData.message,
              icon: 'success'
            })
            break
          case 'transferring':
            // 显示传输进度
            break
          case 'completed':
            console.log('🎉 [升级完成] 开始处理升级完成状态...')
            // 确保隐藏所有可能的loading状态
            this.ensureHideLoading()
            // 延迟一点再显示成功提示，确保loading完全隐藏
            setTimeout(() => {
              console.log('🎉 [升级完成] 显示成功提示...')
              wx.showToast({
                title: progressData.message,
                icon: 'success'
              })
            }, 600) // 增加延迟时间，确保loading完全隐藏
            // 导航到升级进度页面
            setTimeout(() => {
              console.log('🎉 [升级完成] 跳转到进度页面...')
              wx.navigateTo({
                url: '/pages/upgrade/progress/index'
              })
            }, 1500) // 增加延迟时间，确保用户看到成功提示
            break
          case 'failed':
          case 'aborted':
            console.log('❌ [升级失败/中断] 开始处理失败状态...')
            // 确保隐藏所有可能的loading状态
            this.ensureHideLoading()
            // 延迟一点再显示错误提示，确保loading完全隐藏
            setTimeout(() => {
              console.log('❌ [升级失败/中断] 显示错误提示...')
              wx.showToast({
                title: progressData.message,
                icon: 'error'
              })
            }, 600) // 增加延迟时间，确保loading完全隐藏
            break
        }
      }
      
      // 注册监听器
      gaiaManager.addUpgradeListener(upgradeListener)
      this.addUpgradeListener(upgradeListener)
      
      // 调用升级管理器开始升级
      const response = await gaiaManager.startUpgrade(fileData, upgradeOptions)
      
      if (!response.success) {
        console.error('升级启动失败:', response.error)
        this.ensureHideLoading()
        // 延迟一点再显示错误提示，确保loading完全隐藏
        setTimeout(() => {
          wx.showToast({
            title: '升级启动失败: ' + response.error,
            icon: 'error'
          })
        }, 300)
        
        // 发送升级断开命令
        try {
          await gaiaManager.sendCommandWithVendor(0x01, [], 0x001D) // V1_UPGRADE_DISCONNECT
        } catch (disconnectError) {
          console.error('断开升级模式失败:', disconnectError)
        }
      }
      
    } catch (error) {
      console.error('升级启动失败:', error)
      this.ensureHideLoading()
      // 延迟一点再显示错误提示，确保loading完全隐藏
      setTimeout(() => {
        wx.showToast({
          title: '升级启动失败: ' + error.message,
          icon: 'error'
        })
      }, 300)
      
      // 发送升级断开命令
      try {
        await gaiaManager.sendCommandWithVendor(0x01, [], 0x001D) // V1_UPGRADE_DISCONNECT
      } catch (disconnectError) {
        console.error('断开升级模式失败:', disconnectError)
      }
    }
  },

  // 中止升级
  async abortUpgrade() {
    try {
      console.log('中止升级...')
      
      // 确保隐藏所有可能的loading状态
      this.ensureHideLoading()
      
      // 清理后台运行支持
      gaiaManager.cleanupBackgroundSupport()
      
      const response = await gaiaManager.abortUpgrade()
      
      if (response.success) {
        wx.showToast({
          title: response.message,
          icon: 'success'
        })
      } else {
        wx.showToast({
          title: '中止升级失败: ' + response.error,
          icon: 'error'
        })
      }
      
    } catch (error) {
      console.error('中止升级失败:', error)
      // 确保隐藏loading状态
      this.ensureHideLoading()
      wx.showToast({
        title: '中止升级失败: ' + error.message,
        icon: 'error'
      })
    }
  },

  // 显示错误
  showError(message) {
    this.setData({
      showError: true,
      errorMessage: message,
      isLoading: false
    })
  },

  // 下拉刷新
  onPullDownRefresh() {
    this.loadUpgradeData().finally(() => {
      wx.stopPullDownRefresh()
    })
  },

  // Android兼容的字符串解析方法（从设备信息页面复制）
  parseAndroidString(data, vendorId = null) {
    // ✅ 完全匹配Android BytesUtils.getString方法
    if (!data || data.length === 0) {
      console.log('📋 [Android解析] 数据为空，返回空字符串')
      return ""
    }

    console.log('📋 [Android解析] 输入数据:', data)
    console.log('📋 [Android解析] 输入数据(hex):', data.map(b => b.toString(16).padStart(2, '0')).join(' '))
    console.log('📋 [Android解析] Vendor ID:', vendorId ? `0x${vendorId.toString(16).padStart(4, '0')}` : '未知')

    // ✅ 根据协议版本采用不同的解析策略
    let actualData = data
    
    // V3协议：直接使用数据，不处理状态码（匹配Android V3BasicPlugin逻辑）
    if (vendorId === 0x001D) { // QTIL_V3
      console.log('📋 [Android解析] V3协议：直接解析数据，不处理状态码')
      actualData = data
    } else {
      // V1/V2协议：处理状态码（保持原有逻辑）
      console.log('📋 [Android解析] V1/V2协议：处理状态码')
      if (data.length > 0) {
        // 检查第一个字节是否为状态码
        const statusCode = data[0]
        console.log('📋 [Android解析] 状态码:', statusCode, '(0x' + statusCode.toString(16).padStart(2, '0') + ')')
        
        // 根据Android V1V2ErrorStatus枚举处理状态码
        switch (statusCode) {
          case 0x00: // SUCCESS
            console.log('📋 [Android解析] 状态: SUCCESS')
            if (data.length > 1) {
              actualData = data.slice(1)
              console.log('📋 [Android解析] 跳过状态码，实际数据:', actualData)
              console.log('📋 [Android解析] 实际数据(hex):', actualData.map(b => b.toString(16).padStart(2, '0')).join(' '))
            } else {
              console.log('📋 [Android解析] 成功响应但无数据')
              return ""
            }
            break
          case 0x01: // COMMAND_NOT_SUPPORTED
            console.log('📋 [Android解析] 状态: COMMAND_NOT_SUPPORTED - 命令不支持')
            return "命令不支持"
          case 0x02: // NOT_AUTHENTICATED
            console.log('📋 [Android解析] 状态: NOT_AUTHENTICATED - 未认证')
            return "未认证"
          case 0x03: // INSUFFICIENT_RESOURCES
            console.log('📋 [Android解析] 状态: INSUFFICIENT_RESOURCES - 资源不足')
            return "资源不足"
          case 0x04: // AUTHENTICATING
            console.log('📋 [Android解析] 状态: AUTHENTICATING - 认证中')
            return "认证中"
          case 0x05: // INVALID_PARAMETER
            console.log('📋 [Android解析] 状态: INVALID_PARAMETER - 无效参数')
            return "无效参数"
          case 0x06: // INCORRECT_STATE
            console.log('📋 [Android解析] 状态: INCORRECT_STATE - 状态错误')
            return "状态错误"
          case 0x07: // IN_PROGRESS
            console.log('📋 [Android解析] 状态: IN_PROGRESS - 处理中')
            return "处理中"
          default:
            console.log('📋 [Android解析] 状态: UNKNOWN - 未知状态')
            return "未知状态"
        }
      }
    }

    // ✅ 完全匹配Android BytesUtils.getString方法
    let result = ""

    try {
      // 直接使用UTF-8解码（匹配Android StandardCharsets.UTF_8）
      result = this.decodeUtf8(actualData)
      console.log('📋 [Android解析] UTF-8解码结果:', result)
    } catch (exception) {
      console.log('📋 [Android解析] UTF-8解码异常:', exception.message)
      // Android在异常时返回空字符串，不尝试其他方法
      result = ""
    }

    console.log('📋 [Android解析] 最终结果:', result)
    return result
  },

  // UTF-8解码辅助函数（兼容微信小程序）
  decodeUtf8(bytes) {
    if (!bytes || bytes.length === 0) return ''
    
    let result = ''
    let i = 0
    
    while (i < bytes.length) {
      let byte1 = bytes[i++]
      
      if (byte1 < 0x80) {
        // 单字节字符 (ASCII)
        result += String.fromCharCode(byte1)
      } else if ((byte1 >> 5) === 0x06) {
        // 双字节字符
        if (i < bytes.length) {
          let byte2 = bytes[i++]
          result += String.fromCharCode(((byte1 & 0x1F) << 6) | (byte2 & 0x3F))
        }
      } else if ((byte1 >> 4) === 0x0E) {
        // 三字节字符
        if (i + 1 < bytes.length) {
          let byte2 = bytes[i++]
          let byte3 = bytes[i++]
          result += String.fromCharCode(((byte1 & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F))
        }
      } else if ((byte1 >> 3) === 0x1E) {
        // 四字节字符
        if (i + 2 < bytes.length) {
          let byte2 = bytes[i++]
          let byte3 = bytes[i++]
          let byte4 = bytes[i++]
          result += String.fromCharCode(((byte1 & 0x07) << 18) | ((byte2 & 0x3F) << 12) | ((byte3 & 0x3F) << 6) | (byte4 & 0x3F))
        }
      }
    }
    
    return result
  },

  // 设置后台支持
  setupBackgroundSupport() {
    console.log('🔋 [后台支持] 设置后台运行和屏幕常亮支持')
    
    // 设置屏幕常亮
    this.setKeepScreenOn()
    
    // 设置后台运行
    this.setBackgroundMode()
    
    // 监听应用状态变化
    this.setupAppStateListeners()
  },

  // 清理后台支持
  cleanupBackgroundSupport() {
    console.log('🔋 [后台支持] 清理后台运行和屏幕常亮支持')
    
    // 取消屏幕常亮
    this.clearKeepScreenOn()
    
    // 取消后台运行
    this.clearBackgroundMode()
    
    // 清理应用状态监听器
    this.cleanupAppStateListeners()
  },

  // 设置屏幕常亮
  setKeepScreenOn() {
    try {
      wx.setKeepScreenOn({
        keepScreenOn: true,
        success: () => {
          console.log('🔋 [后台支持] 屏幕常亮设置成功')
        },
        fail: (error) => {
          console.warn('🔋 [后台支持] 屏幕常亮设置失败:', error)
        }
      })
    } catch (error) {
      console.warn('🔋 [后台支持] 屏幕常亮设置异常:', error)
    }
  },

  // 取消屏幕常亮
  clearKeepScreenOn() {
    try {
      wx.setKeepScreenOn({
        keepScreenOn: false,
        success: () => {
          console.log('🔋 [后台支持] 屏幕常亮已取消')
        },
        fail: (error) => {
          console.warn('🔋 [后台支持] 取消屏幕常亮失败:', error)
        }
      })
    } catch (error) {
      console.warn('🔋 [后台支持] 取消屏幕常亮异常:', error)
    }
  },

  // 设置后台运行模式
  setBackgroundMode() {
    try {
      // 设置后台运行模式
      wx.setBackgroundFetchToken({
        token: 'upgrade_background_token',
        success: () => {
          console.log('🔋 [后台支持] 后台运行模式设置成功')
        },
        fail: (error) => {
          console.warn('🔋 [后台支持] 后台运行模式设置失败:', error)
        }
      })
    } catch (error) {
      console.warn('🔋 [后台支持] 后台运行模式设置异常:', error)
    }
  },

  // 取消后台运行模式
  clearBackgroundMode() {
    try {
      wx.setBackgroundFetchToken({
        token: '',
        success: () => {
          console.log('🔋 [后台支持] 后台运行模式已取消')
        },
        fail: (error) => {
          console.warn('🔋 [后台支持] 取消后台运行模式失败:', error)
        }
      })
    } catch (error) {
      console.warn('🔋 [后台支持] 取消后台运行模式异常:', error)
    }
  },

  // 设置应用状态监听器
  setupAppStateListeners() {
    // 监听应用进入后台
    this.onAppHide = () => {
      console.log('🔋 [后台支持] 应用进入后台，升级状态:', this.upgradeState)
      if (this.upgradeState === 'transferring') {
        console.log('🔋 [后台支持] 升级正在进行中，保持后台运行')
        // 可以在这里添加后台运行逻辑
      }
    }

    // 监听应用回到前台
    this.onAppShow = () => {
      console.log('🔋 [后台支持] 应用回到前台，升级状态:', this.upgradeState)
      if (this.upgradeState === 'transferring') {
        console.log('🔋 [后台支持] 升级正在进行中，检查连接状态')
        // 检查BLE连接状态
        this.checkConnectionStatus()
      }
    }

    // 注册应用状态监听器
    wx.onAppHide(this.onAppHide)
    wx.onAppShow(this.onAppShow)
  },

  // 清理应用状态监听器
  cleanupAppStateListeners() {
    if (this.onAppHide) {
      wx.offAppHide(this.onAppHide)
      this.onAppHide = null
    }
    if (this.onAppShow) {
      wx.offAppShow(this.onAppShow)
      this.onAppShow = null
    }
  },

  // 检查连接状态
  async checkConnectionStatus() {
    try {
      console.log('🔋 [后台支持] 检查BLE连接状态')
      
      // 检查BLE连接状态
      const connectionState = await wx.getBLEDeviceConnectionState({
        deviceId: gaiaManager.deviceId
      })
      
      if (connectionState.connected) {
        console.log('🔋 [后台支持] BLE连接正常')
        gaiaManager.isConnected = true
      } else {
        console.warn('🔋 [后台支持] BLE连接已断开，尝试重连')
        gaiaManager.isConnected = false
        
        // 如果升级正在进行，尝试重连
        if (this.upgradeState === 'transferring') {
          const reconnectResult = await gaiaManager.attemptReconnection()
          if (!reconnectResult.success) {
            console.error('🔋 [后台支持] 重连失败，升级可能中断')
            this.showError('连接已断开，升级中断')
          }
        }
      }
    } catch (error) {
      console.error('🔋 [后台支持] 检查连接状态失败:', error)
    }
  }
})